类型安全的社交网络：实现社区平台

            interface User {
  id: string;
  username: string;
  email: string;
  createdAt: Date;
  profilePicture?: string; // Optional field
}

interface Post {
  id: string;
  authorId: string; // Foreign key referencing User
  content: string;
  createdAt: Date;
  likes: number;
}

            

              
                Copy
              
            
          

            
type User {
  id: ID!
  username: String!
  email: String!
  createdAt: DateTime!
  profilePicture: String
}

type Post {
  id: ID!
  authorId: ID!
  content: String!
  createdAt: DateTime!
  likes: Int!
}

type Query {
  user(id: ID!): User
  postsByUser(userId: ID!): [Post!]
}

// Scalar Type for DateTime
scalar DateTime

            

              
                Copy
              
            
          

            
import { User, Post } from './generated/graphql'; // Generated types

const resolvers = {
  Query: {
    user: async (_: any, { id }: { id: string }): Promise<User | null> => {
      // Fetch user from database based on id
      const user = await fetchUserFromDatabase(id);
      return user;
    },
    postsByUser: async (_: any, { userId }: { userId: string }): Promise<Post[]> => {
      // Fetch posts from database based on userId
      const posts = await fetchPostsByUserId(userId);
      return posts;
    },
  },
};

async function fetchUserFromDatabase(id: string): Promise<User | null> {
  // Implement fetching from your database, e.g., using a library like Prisma or TypeORM.
  // This function would typically interact with your database to retrieve user data based on the provided ID.
  // It's important to handle cases where the user doesn't exist and return null or throw an error.
  // Example (illustrative only):
  // const user = await db.user.findUnique({ where: { id } });
  // return user;
  return null;
}

async function fetchPostsByUserId(userId: string): Promise<Post[]> {
  // Implement fetching posts from your database based on userId.  Similar to fetchUserFromDatabase, 
  // you'd interact with your database here. Ensure you handle potential errors.
  // Example (illustrative only):
  // const posts = await db.post.findMany({ where: { authorId: userId } });
  // return posts;
  return [];
}

            

              
                Copy
              
            
          

            
import * as Joi from 'joi';

const userSchema = Joi.object({
  id: Joi.string().uuid().required(),
  username: Joi.string().alphanum().min(3).max(30).required(),
  email: Joi.string().email().required(),
  createdAt: Joi.date().iso().required(),
  profilePicture: Joi.string().uri(),
});

// Example of validating input in a resolver:
async userResolver(parent: any, args: { id: string }) {
  try {
    const { value, error } = userSchema.validate(args);
    if (error) {
      throw new Error(`Invalid input: ${error.message}`);
    }
    const user = await fetchUserFromDatabase(value.id);
    return user;
  } catch (error: any) {
    console.error('Error fetching user:', error);
    throw new Error(error.message || 'Internal server error');
  }
}

            

              
                Copy
              
            
          

            
class DataStorage<T> {
  private data: T[] = [];

  add(item: T) {
    this.data.push(item);
  }

  get(index: number): T | undefined {
    return this.data[index];
  }
}

const stringStorage = new DataStorage<string>();
stringStorage.add('hello');
const numberStorage = new DataStorage<number>();
numberStorage.add(123);

            

              
                Copy
              
            
          

            
type UserRole = 'admin' | 'moderator' | 'user';

interface User {
  id: string;
  username: string;
}

interface AdminUser extends User {
  role: 'admin';
  permissions: string[];
}

interface ModeratorUser extends User {
  role: 'moderator';
  moderationTools: string[];
}

            

              
                Copy
              
            
          

            
// Define a type for your language keys
interface TranslationKeys {
  greeting: string;
  welcomeMessage: string;
  // ... other keys
}

// A typed function to fetch translations
function translate<K extends keyof TranslationKeys>(key: K, language: string): string {
  // Implement fetching the correct translation, e.g., from a JSON file.
  const translations: { [lang: string]: TranslationKeys } = {
    en: {
      greeting: 'Hello',
      welcomeMessage: 'Welcome to our platform',
    },
    es: {
      greeting: 'Hola',
      welcomeMessage: 'Bienvenido a nuestra plataforma',
    },
    // ... other languages
  };
  return translations[language][key] || key; // Fallback to key if translation not found
}

const greeting = translate('greeting', 'es'); // 'Hola'
const welcome = translate('welcomeMessage', 'en'); // 'Welcome to our platform'

            

              
                Copy